home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex7 < prev    next >
Encoding:
Text File  |  1988-05-19  |  48.3 KB  |  2,154 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. insertdollarsign () {
  5.     insertdollarsign_regmem 
  6.   backinput () ; 
  7.   curtok = 804 ; 
  8.   {
  9.     if ( interaction == 3 ) 
  10.     wakeupterminal () ; 
  11.     printnl ( 133 ) ; 
  12.     print ( 865 ) ; 
  13.   } 
  14.   {
  15.     helpptr = 2 ; 
  16.     helpline [ 1 ] = 866 ; 
  17.     helpline [ 0 ] = 867 ; 
  18.   } 
  19.   inserror () ; 
  20. } 
  21. youcant () {
  22.     youcant_regmem 
  23.   {
  24.     if ( interaction == 3 ) 
  25.     wakeupterminal () ; 
  26.     printnl ( 133 ) ; 
  27.     print ( 541 ) ; 
  28.   } 
  29.   printcmdchr ( curcmd , curchr ) ; 
  30.   print ( 868 ) ; 
  31.   printmode ( curlist .modefield ) ; 
  32. } 
  33. reportillegalcase () {
  34.     reportillegalcase_regmem 
  35.   youcant () ; 
  36.   {
  37.     helpptr = 4 ; 
  38.     helpline [ 3 ] = 869 ; 
  39.     helpline [ 2 ] = 870 ; 
  40.     helpline [ 1 ] = 871 ; 
  41.     helpline [ 0 ] = 872 ; 
  42.   } 
  43.   error () ; 
  44. } 
  45. boolean privileged () {
  46.     register boolean Result; privileged_regmem 
  47.   if ( curlist .modefield > 0 ) 
  48.   Result = true ; 
  49.   else {
  50.       
  51.     reportillegalcase () ; 
  52.     Result = false ; 
  53.   } 
  54.   return(Result) ; 
  55. } 
  56. boolean itsallover () {
  57.     /* 10 */ register boolean Result; itsallover_regmem 
  58.   if ( privileged () ) 
  59.   {
  60.     if ( ( memtop - 2 == pagetail ) && ( curlist .headfield == curlist 
  61.     .tailfield ) && ( deadcycles == 0 ) ) 
  62.     {
  63.       Result = true ; 
  64.       return(Result) ; 
  65.     } 
  66.     backinput () ; 
  67.     {
  68.       mem [ curlist .tailfield ] .hh .v.RH = newnullbox () ; 
  69.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  70.     } 
  71.     mem [ curlist .tailfield + 1 ] .cint = eqtb [ 5704 ] .cint ; 
  72.     {
  73.       mem [ curlist .tailfield ] .hh .v.RH = newglue ( 8 ) ; 
  74.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  75.     } 
  76.     {
  77.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( -1073741824L ) ; 
  78.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  79.     } 
  80.     buildpage () ; 
  81.   } 
  82.   Result = false ; 
  83.   return(Result) ; 
  84. } 
  85. appendglue () {
  86.     appendglue_regmem 
  87.   smallnumber s  ; 
  88.   s = curchr ; 
  89.   switch ( s ) 
  90.   {case 0 : 
  91.     curval = 4 ; 
  92.     break ; 
  93.   case 1 : 
  94.     curval = 8 ; 
  95.     break ; 
  96.   case 2 : 
  97.     curval = 12 ; 
  98.     break ; 
  99.   case 3 : 
  100.     curval = 16 ; 
  101.     break ; 
  102.   case 4 : 
  103.     scanglue ( 2 ) ; 
  104.     break ; 
  105.   case 5 : 
  106.     scanglue ( 3 ) ; 
  107.     break ; 
  108.   } 
  109.   {
  110.     mem [ curlist .tailfield ] .hh .v.RH = newglue ( curval ) ; 
  111.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  112.   } 
  113.   if ( s >= 4 ) 
  114.   {
  115.     decr ( mem [ curval ] .hh .v.RH ) ; 
  116.     if ( s > 4 ) 
  117.     mem [ curlist .tailfield ] .hh.b1 = 99 ; 
  118.   } 
  119. } 
  120. appendkern () {
  121.     appendkern_regmem 
  122.   quarterword s  ; 
  123.   s = curchr ; 
  124.   scandimen ( s == 99 , false , false ) ; 
  125.   {
  126.     mem [ curlist .tailfield ] .hh .v.RH = newkern ( curval ) ; 
  127.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  128.   } 
  129.   mem [ curlist .tailfield ] .hh.b1 = s ; 
  130. } 
  131. offsave () {
  132.     offsave_regmem 
  133.   halfword p  ; 
  134.   if ( curgroup == 0 ) 
  135.   {
  136.     {
  137.       if ( interaction == 3 ) 
  138.       wakeupterminal () ; 
  139.       printnl ( 133 ) ; 
  140.       print ( 633 ) ; 
  141.     } 
  142.     printcmdchr ( curcmd , curchr ) ; 
  143.     {
  144.       helpptr = 1 ; 
  145.       helpline [ 0 ] = 891 ; 
  146.     } 
  147.     error () ; 
  148.   } 
  149.   else {
  150.       
  151.     backinput () ; 
  152.     p = getavail () ; 
  153.     mem [ memtop - 3 ] .hh .v.RH = p ; 
  154.     {
  155.       if ( interaction == 3 ) 
  156.       wakeupterminal () ; 
  157.       printnl ( 133 ) ; 
  158.       print ( 483 ) ; 
  159.     } 
  160.     switch ( curgroup ) 
  161.     {case 14 : 
  162.       {
  163.     mem [ p ] .hh .v.LH = 7356 ; 
  164.     printesc ( 375 ) ; 
  165.       } 
  166.       break ; 
  167.     case 15 : 
  168.       {
  169.     mem [ p ] .hh .v.LH = 804 ; 
  170.     printchar ( 36 ) ; 
  171.       } 
  172.       break ; 
  173.     case 16 : 
  174.       {
  175.     mem [ p ] .hh .v.LH = 7357 ; 
  176.     mem [ p ] .hh .v.RH = getavail () ; 
  177.     p = mem [ p ] .hh .v.RH ; 
  178.     mem [ p ] .hh .v.LH = 3118 ; 
  179.     printesc ( 890 ) ; 
  180.       } 
  181.       break ; 
  182.       default: 
  183.       {
  184.     mem [ p ] .hh .v.LH = 637 ; 
  185.     printchar ( 125 ) ; 
  186.       } 
  187.       break ; 
  188.     } 
  189.     print ( 484 ) ; 
  190.     begintokenlist ( mem [ memtop - 3 ] .hh .v.RH , 4 ) ; 
  191.     {
  192.       helpptr = 5 ; 
  193.       helpline [ 4 ] = 885 ; 
  194.       helpline [ 3 ] = 886 ; 
  195.       helpline [ 2 ] = 887 ; 
  196.       helpline [ 1 ] = 888 ; 
  197.       helpline [ 0 ] = 889 ; 
  198.     } 
  199.     error () ; 
  200.   } 
  201. } 
  202. extrarightbrace () {
  203.     extrarightbrace_regmem 
  204.   {
  205.     if ( interaction == 3 ) 
  206.     wakeupterminal () ; 
  207.     printnl ( 133 ) ; 
  208.     print ( 896 ) ; 
  209.   } 
  210.   switch ( curgroup ) 
  211.   {case 14 : 
  212.     printesc ( 375 ) ; 
  213.     break ; 
  214.   case 15 : 
  215.     printchar ( 36 ) ; 
  216.     break ; 
  217.   case 16 : 
  218.     printesc ( 730 ) ; 
  219.     break ; 
  220.   } 
  221.   {
  222.     helpptr = 5 ; 
  223.     helpline [ 4 ] = 897 ; 
  224.     helpline [ 3 ] = 898 ; 
  225.     helpline [ 2 ] = 899 ; 
  226.     helpline [ 1 ] = 900 ; 
  227.     helpline [ 0 ] = 901 ; 
  228.   } 
  229.   error () ; 
  230.   incr ( alignstate ) ; 
  231. } 
  232. normalparagraph () {
  233.     normalparagraph_regmem 
  234.   if ( eqtb [ 5286 ] .cint != 0 ) 
  235.   eqworddefine ( 5286 , 0 ) ; 
  236.   if ( eqtb [ 5718 ] .cint != 0 ) 
  237.   eqworddefine ( 5718 , 0 ) ; 
  238.   if ( eqtb [ 5308 ] .cint != 1 ) 
  239.   eqworddefine ( 5308 , 1 ) ; 
  240.   if ( eqtb [ 4056 ] .hh .v.RH != 0 ) 
  241.   eqdefine ( 4056 , 117 , 0 ) ; 
  242. } 
  243. boxend () {
  244.     boxend_regmem 
  245.   halfword p  ; 
  246.   if ( savestack [ saveptr + 0 ] .cint < 1073741824L ) 
  247.   {
  248.     if ( curbox != 0 ) 
  249.     {
  250.       mem [ curbox + 4 ] .cint = savestack [ saveptr + 0 ] .cint ; 
  251.       if ( abs ( curlist .modefield ) == 1 ) 
  252.       {
  253.     appendtovlist ( curbox ) ; 
  254.     if ( adjusttail != 0 ) 
  255.     {
  256.       if ( memtop - 5 != adjusttail ) 
  257.       {
  258.         mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 5 ] .hh 
  259.         .v.RH ; 
  260.         curlist .tailfield = adjusttail ; 
  261.       } 
  262.       adjusttail = 0 ; 
  263.     } 
  264.     if ( curlist .modefield > 0 ) 
  265.     buildpage () ; 
  266.       } 
  267.       else {
  268.       
  269.     if ( abs ( curlist .modefield ) == 101 ) 
  270.     curlist .auxfield = 1000 ; 
  271.     else {
  272.         
  273.       p = newnoad () ; 
  274.       mem [ p + 1 ] .hh .v.RH = 2 ; 
  275.       mem [ p + 1 ] .hh .v.LH = curbox ; 
  276.       curbox = p ; 
  277.     } 
  278.     mem [ curlist .tailfield ] .hh .v.RH = curbox ; 
  279.     curlist .tailfield = curbox ; 
  280.       } 
  281.     } 
  282.   } 
  283.   else if ( savestack [ saveptr + 0 ] .cint < 1073742336L ) 
  284.   if ( savestack [ saveptr + 0 ] .cint < 1073742080L ) 
  285.   eqdefine ( -1073737502L + savestack [ saveptr + 0 ] .cint , 118 , curbox ) ; 
  286.   else geqdefine ( -1073737758L + savestack [ saveptr + 0 ] .cint , 118 , 
  287.   curbox ) ; 
  288.   else if ( curbox != 0 ) 
  289.   if ( savestack [ saveptr + 0 ] .cint > 1073742336L ) 
  290.   {
  291.     do {
  292.     getxtoken () ; 
  293.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  294.     if ( ( ( curcmd == 26 ) && ( abs ( curlist .modefield ) != 1 ) ) || ( ( 
  295.     curcmd == 27 ) && ( abs ( curlist .modefield ) == 1 ) ) || ( ( curcmd == 
  296.     28 ) && ( abs ( curlist .modefield ) == 201 ) ) ) 
  297.     {
  298.       appendglue () ; 
  299.       mem [ curlist .tailfield ] .hh.b1 = savestack [ saveptr + 0 ] .cint - ( 
  300.       1073742237L ) ; 
  301.       mem [ curlist .tailfield + 1 ] .hh .v.RH = curbox ; 
  302.     } 
  303.     else {
  304.     
  305.       {
  306.     if ( interaction == 3 ) 
  307.     wakeupterminal () ; 
  308.     printnl ( 133 ) ; 
  309.     print ( 914 ) ; 
  310.       } 
  311.       {
  312.     helpptr = 3 ; 
  313.     helpline [ 2 ] = 915 ; 
  314.     helpline [ 1 ] = 916 ; 
  315.     helpline [ 0 ] = 917 ; 
  316.       } 
  317.       backerror () ; 
  318.       flushnodelist ( curbox ) ; 
  319.     } 
  320.   } 
  321.   else shipout ( curbox ) ; 
  322. } 
  323. beginbox () {
  324.     /* 10 30 */ beginbox_regmem 
  325.   halfword p, q  ; 
  326.   quarterword m  ; 
  327.   halfword k  ; 
  328.   eightbits n  ; 
  329.   switch ( curchr ) 
  330.   {case 0 : 
  331.     {
  332.       scaneightbitint () ; 
  333.       curbox = eqtb [ 4322 + curval ] .hh .v.RH ; 
  334.       eqtb [ 4322 + curval ] .hh .v.RH = 0 ; 
  335.     } 
  336.     break ; 
  337.   case 1 : 
  338.     {
  339.       scaneightbitint () ; 
  340.       curbox = copynodelist ( eqtb [ 4322 + curval ] .hh .v.RH ) ; 
  341.     } 
  342.     break ; 
  343.   case 2 : 
  344.     {
  345.       curbox = 0 ; 
  346.       if ( abs ( curlist .modefield ) == 201 ) 
  347.       {
  348.     youcant () ; 
  349.     {
  350.       helpptr = 1 ; 
  351.       helpline [ 0 ] = 918 ; 
  352.     } 
  353.     error () ; 
  354.       } 
  355.       else if ( ( curlist .modefield == 1 ) && ( curlist .headfield == curlist 
  356.       .tailfield ) ) 
  357.       {
  358.     youcant () ; 
  359.     {
  360.       helpptr = 2 ; 
  361.       helpline [ 1 ] = 919 ; 
  362.       helpline [ 0 ] = 920 ; 
  363.     } 
  364.     error () ; 
  365.       } 
  366.       else {
  367.       
  368.     if ( ! ( curlist .tailfield >= himemmin ) ) 
  369.     if ( ( mem [ curlist .tailfield ] .hh.b0 == 0 ) || ( mem [ curlist 
  370.     .tailfield ] .hh.b0 == 1 ) ) 
  371.     {
  372.       q = curlist .headfield ; 
  373.       do {
  374.           p = q ; 
  375.         if ( ! ( q >= himemmin ) ) 
  376.         if ( mem [ q ] .hh.b0 == 7 ) 
  377.         {
  378.           {register integer for_end; m = 1 ; for_end = mem [ q ] .hh.b1 
  379.           ; if ( m <= for_end) do 
  380.         p = mem [ p ] .hh .v.RH ; 
  381.           while ( m++ < for_end ) ; } 
  382.           if ( p == curlist .tailfield ) 
  383.           goto lab30 ; 
  384.         } 
  385.         q = mem [ p ] .hh .v.RH ; 
  386.       } while ( ! ( q == curlist .tailfield ) ) ; 
  387.       curbox = curlist .tailfield ; 
  388.       mem [ curbox + 4 ] .cint = 0 ; 
  389.       curlist .tailfield = p ; 
  390.       mem [ p ] .hh .v.RH = 0 ; 
  391.       lab30: ; 
  392.     } 
  393.       } 
  394.     } 
  395.     break ; 
  396.   case 3 : 
  397.     {
  398.       scaneightbitint () ; 
  399.       n = curval ; 
  400.       if ( ! scankeyword ( 695 ) ) 
  401.       {
  402.     {
  403.       if ( interaction == 3 ) 
  404.       wakeupterminal () ; 
  405.       printnl ( 133 ) ; 
  406.       print ( 921 ) ; 
  407.     } 
  408.     {
  409.       helpptr = 2 ; 
  410.       helpline [ 1 ] = 922 ; 
  411.       helpline [ 0 ] = 923 ; 
  412.     } 
  413.     error () ; 
  414.       } 
  415.       scandimen ( false , false , false ) ; 
  416.       curbox = vsplit ( n , curval ) ; 
  417.     } 
  418.     break ; 
  419.     default: 
  420.     {
  421.       k = curchr - 4 ; 
  422.       incr ( saveptr ) ; 
  423.       scanspec () ; 
  424.       if ( k == 101 ) 
  425.       if ( ( savestack [ saveptr - 3 ] .cint < 1073741824L ) && ( abs ( 
  426.       curlist .modefield ) == 1 ) ) 
  427.       newsavelevel ( 3 ) ; 
  428.       else newsavelevel ( 2 ) ; 
  429.       else {
  430.       
  431.     if ( k == 1 ) 
  432.     newsavelevel ( 4 ) ; 
  433.     else {
  434.         
  435.       newsavelevel ( 5 ) ; 
  436.       k = 1 ; 
  437.     } 
  438.     normalparagraph () ; 
  439.       } 
  440.       pushnest () ; 
  441.       curlist .modefield = - (integer) k ; 
  442.       if ( k == 1 ) 
  443.       {
  444.     curlist .auxfield = -65536000L ; 
  445.     if ( eqtb [ 4062 ] .hh .v.RH != 0 ) 
  446.     begintokenlist ( eqtb [ 4062 ] .hh .v.RH , 11 ) ; 
  447.       } 
  448.       else {
  449.       
  450.     curlist .auxfield = 1000 ; 
  451.     if ( eqtb [ 4061 ] .hh .v.RH != 0 ) 
  452.     begintokenlist ( eqtb [ 4061 ] .hh .v.RH , 10 ) ; 
  453.       } 
  454.       return ; 
  455.     } 
  456.     break ; 
  457.   } 
  458.   boxend () ; 
  459. } 
  460. scanbox () {
  461.     scanbox_regmem 
  462.   do {
  463.       getxtoken () ; 
  464.   } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  465.   if ( curcmd == 20 ) 
  466.   beginbox () ; 
  467.   else if ( ( savestack [ saveptr + 0 ] .cint >= 1073742337L ) && ( ( curcmd 
  468.   == 36 ) || ( curcmd == 35 ) ) ) 
  469.   {
  470.     curbox = scanrulespec () ; 
  471.     boxend () ; 
  472.   } 
  473.   else {
  474.       
  475.     {
  476.       if ( interaction == 3 ) 
  477.       wakeupterminal () ; 
  478.       printnl ( 133 ) ; 
  479.       print ( 924 ) ; 
  480.     } 
  481.     {
  482.       helpptr = 3 ; 
  483.       helpline [ 2 ] = 925 ; 
  484.       helpline [ 1 ] = 926 ; 
  485.       helpline [ 0 ] = 927 ; 
  486.     } 
  487.     backerror () ; 
  488.   } 
  489. } 
  490. zpackage ( c ) 
  491. smallnumber c ; 
  492. {package_regmem 
  493.   scaled h  ; 
  494.   halfword p  ; 
  495.   scaled d  ; 
  496.   d = eqtb [ 5708 ] .cint ; 
  497.   unsave () ; 
  498.   saveptr = saveptr - 3 ; 
  499.   if ( curlist .modefield == -101 ) 
  500.   curbox = hpack ( mem [ curlist .headfield ] .hh .v.RH , savestack [ saveptr 
  501.   + 2 ] .cint , savestack [ saveptr + 1 ] .cint ) ; 
  502.   else {
  503.       
  504.     curbox = vpackage ( mem [ curlist .headfield ] .hh .v.RH , savestack [ 
  505.     saveptr + 2 ] .cint , savestack [ saveptr + 1 ] .cint , d ) ; 
  506.     if ( c == 4 ) 
  507.     {
  508.       h = 0 ; 
  509.       p = mem [ curbox + 5 ] .hh .v.RH ; 
  510.       if ( p != 0 ) 
  511.       if ( mem [ p ] .hh.b0 <= 2 ) 
  512.       h = mem [ p + 3 ] .cint ; 
  513.       mem [ curbox + 2 ] .cint = mem [ curbox + 2 ] .cint - h + mem [ curbox + 
  514.       3 ] .cint ; 
  515.       mem [ curbox + 3 ] .cint = h ; 
  516.     } 
  517.   } 
  518.   popnest () ; 
  519.   boxend () ; 
  520. } 
  521. znewgraf ( indented ) 
  522. boolean indented ; 
  523. {newgraf_regmem 
  524.   curlist .pgfield = 0 ; 
  525.   if ( ( curlist .modefield == 1 ) || ( curlist .headfield != curlist 
  526.   .tailfield ) ) 
  527.   {
  528.     mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( 2 ) ; 
  529.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  530.   } 
  531.   pushnest () ; 
  532.   curlist .modefield = 101 ; 
  533.   curlist .auxfield = 1000 ; 
  534.   if ( indented ) 
  535.   {
  536.     curlist .tailfield = newnullbox () ; 
  537.     mem [ curlist .headfield ] .hh .v.RH = curlist .tailfield ; 
  538.     mem [ curlist .tailfield + 1 ] .cint = eqtb [ 5701 ] .cint ; 
  539.   } 
  540.   if ( eqtb [ 4058 ] .hh .v.RH != 0 ) 
  541.   begintokenlist ( eqtb [ 4058 ] .hh .v.RH , 7 ) ; 
  542.   if ( nestptr == 1 ) 
  543.   buildpage () ; 
  544. } 
  545. indentinhmode () {
  546.     indentinhmode_regmem 
  547.   halfword p, q  ; 
  548.   if ( curchr > 0 ) 
  549.   {
  550.     p = newnullbox () ; 
  551.     mem [ p + 1 ] .cint = eqtb [ 5701 ] .cint ; 
  552.     if ( abs ( curlist .modefield ) == 101 ) 
  553.     curlist .auxfield = 1000 ; 
  554.     else {
  555.     
  556.       q = newnoad () ; 
  557.       mem [ q + 1 ] .hh .v.RH = 2 ; 
  558.       mem [ q + 1 ] .hh .v.LH = p ; 
  559.       p = q ; 
  560.     } 
  561.     {
  562.       mem [ curlist .tailfield ] .hh .v.RH = p ; 
  563.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  564.     } 
  565.   } 
  566. } 
  567. headforvmode () {
  568.     headforvmode_regmem 
  569.   if ( curlist .modefield < 0 ) 
  570.   if ( curcmd != 36 ) 
  571.   offsave () ; 
  572.   else {
  573.       
  574.     {
  575.       if ( interaction == 3 ) 
  576.       wakeupterminal () ; 
  577.       printnl ( 133 ) ; 
  578.       print ( 541 ) ; 
  579.     } 
  580.     printesc ( 380 ) ; 
  581.     print ( 930 ) ; 
  582.     {
  583.       helpptr = 2 ; 
  584.       helpline [ 1 ] = 931 ; 
  585.       helpline [ 0 ] = 932 ; 
  586.     } 
  587.     error () ; 
  588.   } 
  589.   else {
  590.       
  591.     backinput () ; 
  592.     curtok = partoken ; 
  593.     backinput () ; 
  594.     curinput .indexfield = 4 ; 
  595.   } 
  596. } 
  597. endgraf () {
  598.     endgraf_regmem 
  599.   if ( curlist .modefield == 101 ) 
  600.   {
  601.     if ( curlist .headfield == curlist .tailfield ) 
  602.     popnest () ; 
  603.     else linebreak ( eqtb [ 5273 ] .cint ) ; 
  604.     normalparagraph () ; 
  605.     errorcount = 0 ; 
  606.   } 
  607. } 
  608. begininsertoradjust () {
  609.     begininsertoradjust_regmem 
  610.   if ( curcmd == 38 ) 
  611.   curval = 255 ; 
  612.   else {
  613.       
  614.     scaneightbitint () ; 
  615.     if ( curval == 255 ) 
  616.     {
  617.       {
  618.     if ( interaction == 3 ) 
  619.     wakeupterminal () ; 
  620.     printnl ( 133 ) ; 
  621.     print ( 933 ) ; 
  622.       } 
  623.       printesc ( 198 ) ; 
  624.       printint ( 255 ) ; 
  625.       {
  626.     helpptr = 1 ; 
  627.     helpline [ 0 ] = 934 ; 
  628.       } 
  629.       error () ; 
  630.       curval = 0 ; 
  631.     } 
  632.   } 
  633.   savestack [ saveptr + 0 ] .cint = curval ; 
  634.   incr ( saveptr ) ; 
  635.   newsavelevel ( 11 ) ; 
  636.   scanleftbrace () ; 
  637.   normalparagraph () ; 
  638.   pushnest () ; 
  639.   curlist .modefield = -1 ; 
  640.   curlist .auxfield = -65536000L ; 
  641. } 
  642. makemark () {
  643.     makemark_regmem 
  644.   halfword p  ; 
  645.   p = scantoks ( false , true ) ; 
  646.   p = getnode ( 2 ) ; 
  647.   mem [ p ] .hh.b0 = 4 ; 
  648.   mem [ p ] .hh.b1 = 0 ; 
  649.   mem [ p + 1 ] .cint = defref ; 
  650.   mem [ curlist .tailfield ] .hh .v.RH = p ; 
  651.   curlist .tailfield = p ; 
  652. } 
  653. appendpenalty () {
  654.     appendpenalty_regmem 
  655.   scanint () ; 
  656.   {
  657.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( curval ) ; 
  658.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  659.   } 
  660.   if ( curlist .modefield == 1 ) 
  661.   buildpage () ; 
  662. } 
  663. deletelast () {
  664.     /* 10 */ deletelast_regmem 
  665.   halfword p, q  ; 
  666.   quarterword m  ; 
  667.   if ( ( curlist .modefield == 1 ) && ( curlist .tailfield == curlist 
  668.   .headfield ) ) 
  669.   {
  670.     if ( ( curchr != 10 ) || ( lastglue != 65535L ) ) 
  671.     {
  672.       youcant () ; 
  673.       {
  674.     helpptr = 2 ; 
  675.     helpline [ 1 ] = 919 ; 
  676.     helpline [ 0 ] = 935 ; 
  677.       } 
  678.       if ( curchr == 11 ) 
  679.       helpline [ 0 ] = ( 936 ) ; 
  680.       else if ( curchr != 10 ) 
  681.       helpline [ 0 ] = ( 937 ) ; 
  682.       error () ; 
  683.     } 
  684.   } 
  685.   else {
  686.       
  687.     if ( ! ( curlist .tailfield >= himemmin ) ) 
  688.     if ( mem [ curlist .tailfield ] .hh.b0 == curchr ) 
  689.     {
  690.       q = curlist .headfield ; 
  691.       do {
  692.       p = q ; 
  693.     if ( ! ( q >= himemmin ) ) 
  694.     if ( mem [ q ] .hh.b0 == 7 ) 
  695.     {
  696.       {register integer for_end; m = 1 ; for_end = mem [ q ] .hh.b1 
  697.       ; if ( m <= for_end) do 
  698.         p = mem [ p ] .hh .v.RH ; 
  699.       while ( m++ < for_end ) ; } 
  700.       if ( p == curlist .tailfield ) 
  701.       return ; 
  702.     } 
  703.     q = mem [ p ] .hh .v.RH ; 
  704.       } while ( ! ( q == curlist .tailfield ) ) ; 
  705.       mem [ p ] .hh .v.RH = 0 ; 
  706.       flushnodelist ( curlist .tailfield ) ; 
  707.       curlist .tailfield = p ; 
  708.     } 
  709.   } 
  710. } 
  711. unpackage () {
  712.     /* 10 */ unpackage_regmem 
  713.   halfword p  ; 
  714.   schar c  ; 
  715.   c = curchr ; 
  716.   scaneightbitint () ; 
  717.   p = eqtb [ 4322 + curval ] .hh .v.RH ; 
  718.   if ( p == 0 ) 
  719.   return ; 
  720.   if ( ( abs ( curlist .modefield ) == 201 ) || ( ( abs ( curlist .modefield ) 
  721.   == 1 ) && ( mem [ p ] .hh.b0 != 1 ) ) || ( ( abs ( curlist .modefield ) == 
  722.   101 ) && ( mem [ p ] .hh.b0 != 0 ) ) ) 
  723.   {
  724.     {
  725.       if ( interaction == 3 ) 
  726.       wakeupterminal () ; 
  727.       printnl ( 133 ) ; 
  728.       print ( 945 ) ; 
  729.     } 
  730.     {
  731.       helpptr = 3 ; 
  732.       helpline [ 2 ] = 946 ; 
  733.       helpline [ 1 ] = 947 ; 
  734.       helpline [ 0 ] = 948 ; 
  735.     } 
  736.     error () ; 
  737.     return ; 
  738.   } 
  739.   if ( c == 1 ) 
  740.   mem [ curlist .tailfield ] .hh .v.RH = copynodelist ( mem [ p + 5 ] .hh 
  741.   .v.RH ) ; 
  742.   else {
  743.       
  744.     mem [ curlist .tailfield ] .hh .v.RH = mem [ p + 5 ] .hh .v.RH ; 
  745.     eqtb [ 4322 + curval ] .hh .v.RH = 0 ; 
  746.     freenode ( p , 7 ) ; 
  747.   } 
  748.   while ( mem [ curlist .tailfield ] .hh .v.RH != 0 ) curlist .tailfield = mem 
  749.   [ curlist .tailfield ] .hh .v.RH ; 
  750. } 
  751. appenditaliccorrecti () {
  752.     /* 10 */ appenditaliccorrecti_regmem 
  753.   halfword p  ; 
  754.   internalfontnumber f  ; 
  755.   if ( curlist .tailfield != curlist .headfield ) 
  756.   {
  757.     if ( ( curlist .tailfield >= himemmin ) ) 
  758.     p = curlist .tailfield ; 
  759.     else if ( mem [ curlist .tailfield ] .hh.b0 == 6 ) 
  760.     p = curlist .tailfield + 1 ; 
  761.     else return ; 
  762.     f = mem [ p ] .hh.b0 ; 
  763.     {
  764.       mem [ curlist .tailfield ] .hh .v.RH = newkern ( fontinfo [ italicbase [ 
  765.       f ] + ( fontinfo [ charbase [ f ] + mem [ p ] .hh.b1 ] .qqqq .b2 ) / 4 ] 
  766.       .cint ) ; 
  767.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  768.     } 
  769.     mem [ curlist .tailfield ] .hh.b1 = 1 ; 
  770.   } 
  771. } 
  772. appenddiscretionary () {
  773.     appenddiscretionary_regmem 
  774.   integer c  ; 
  775.   {
  776.     mem [ curlist .tailfield ] .hh .v.RH = newdisc () ; 
  777.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  778.   } 
  779.   if ( curchr == 1 ) 
  780.   {
  781.     c = hyphenchar [ eqtb [ 4578 ] .hh .v.RH ] ; 
  782.     if ( c >= 0 ) 
  783.     if ( c < 256 ) 
  784.     mem [ curlist .tailfield + 1 ] .hh .v.LH = newcharacter ( eqtb [ 4578 ] 
  785.     .hh .v.RH , c ) ; 
  786.   } 
  787.   else {
  788.       
  789.     incr ( saveptr ) ; 
  790.     savestack [ saveptr - 1 ] .cint = 0 ; 
  791.     scanleftbrace () ; 
  792.     newsavelevel ( 10 ) ; 
  793.     pushnest () ; 
  794.     curlist .modefield = -101 ; 
  795.     curlist .auxfield = 1000 ; 
  796.   } 
  797. } 
  798. builddiscretionary () {
  799.     /* 30 10 */ builddiscretionary_regmem 
  800.   halfword p, q  ; 
  801.   integer n  ; 
  802.   unsave () ; 
  803.   q = curlist .headfield ; 
  804.   p = mem [ q ] .hh .v.RH ; 
  805.   n = 0 ; 
  806.   while ( p != 0 ) {
  807.       
  808.     if ( ! ( p >= himemmin ) ) 
  809.     if ( mem [ p ] .hh.b0 > 2 ) 
  810.     if ( mem [ p ] .hh.b0 != 11 ) 
  811.     if ( mem [ p ] .hh.b0 != 6 ) 
  812.     {
  813.       {
  814.     if ( interaction == 3 ) 
  815.     wakeupterminal () ; 
  816.     printnl ( 133 ) ; 
  817.     print ( 955 ) ; 
  818.       } 
  819.       {
  820.     helpptr = 1 ; 
  821.     helpline [ 0 ] = 956 ; 
  822.       } 
  823.       error () ; 
  824.       begindiagnostic () ; 
  825.       printnl ( 957 ) ; 
  826.       showbox ( p ) ; 
  827.       enddiagnostic ( true ) ; 
  828.       flushnodelist ( p ) ; 
  829.       mem [ q ] .hh .v.RH = 0 ; 
  830.       goto lab30 ; 
  831.     } 
  832.     q = p ; 
  833.     p = mem [ q ] .hh .v.RH ; 
  834.     incr ( n ) ; 
  835.   } 
  836.   lab30: ; 
  837.   p = mem [ curlist .headfield ] .hh .v.RH ; 
  838.   popnest () ; 
  839.   switch ( savestack [ saveptr - 1 ] .cint ) 
  840.   {case 0 : 
  841.     mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  842.     break ; 
  843.   case 1 : 
  844.     mem [ curlist .tailfield + 1 ] .hh .v.RH = p ; 
  845.     break ; 
  846.   case 2 : 
  847.     {
  848.       if ( ( n > 0 ) && ( abs ( curlist .modefield ) == 201 ) ) 
  849.       {
  850.     {
  851.       if ( interaction == 3 ) 
  852.       wakeupterminal () ; 
  853.       printnl ( 133 ) ; 
  854.       print ( 949 ) ; 
  855.     } 
  856.     printesc ( 217 ) ; 
  857.     {
  858.       helpptr = 2 ; 
  859.       helpline [ 1 ] = 950 ; 
  860.       helpline [ 0 ] = 951 ; 
  861.     } 
  862.     flushnodelist ( p ) ; 
  863.     n = 0 ; 
  864.     error () ; 
  865.       } 
  866.       else mem [ curlist .tailfield ] .hh .v.RH = p ; 
  867.       if ( n <= 255 ) 
  868.       mem [ curlist .tailfield ] .hh.b1 = n ; 
  869.       else {
  870.       
  871.     {
  872.       if ( interaction == 3 ) 
  873.       wakeupterminal () ; 
  874.       printnl ( 133 ) ; 
  875.       print ( 952 ) ; 
  876.     } 
  877.     {
  878.       helpptr = 2 ; 
  879.       helpline [ 1 ] = 953 ; 
  880.       helpline [ 0 ] = 954 ; 
  881.     } 
  882.     error () ; 
  883.       } 
  884.       if ( n > 0 ) 
  885.       curlist .tailfield = q ; 
  886.       decr ( saveptr ) ; 
  887.       return ; 
  888.     } 
  889.     break ; 
  890.   } 
  891.   incr ( savestack [ saveptr - 1 ] .cint ) ; 
  892.   scanleftbrace () ; 
  893.   newsavelevel ( 10 ) ; 
  894.   pushnest () ; 
  895.   curlist .modefield = -101 ; 
  896.   curlist .auxfield = 1000 ; 
  897. } 
  898. makeaccent () {
  899.     makeaccent_regmem 
  900.   real s, t  ; 
  901.   halfword p, q, r  ; 
  902.   internalfontnumber f  ; 
  903.   scaled a, h, x, w, delta  ; 
  904.   fourquarters i  ; 
  905.   scancharnum () ; 
  906.   f = eqtb [ 4578 ] .hh .v.RH ; 
  907.   p = newcharacter ( f , curval ) ; 
  908.   if ( p != 0 ) 
  909.   {
  910.     x = fontinfo [ 5 + parambase [ f ] ] .cint ; 
  911.     s = fontinfo [ 1 + parambase [ f ] ] .cint / ((double) 65536.0 ) ; 
  912.     a = fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + mem [ p ] 
  913.     .hh.b1 ] .qqqq .b0 ] .cint ; 
  914.     doassignments () ; 
  915.     q = 0 ; 
  916.     f = eqtb [ 4578 ] .hh .v.RH ; 
  917.     if ( ( curcmd == 11 ) || ( curcmd == 12 ) || ( curcmd == 67 ) ) 
  918.     q = newcharacter ( f , curchr ) ; 
  919.     else if ( curcmd == 16 ) 
  920.     {
  921.       scancharnum () ; 
  922.       q = newcharacter ( f , curval ) ; 
  923.     } 
  924.     else backinput () ; 
  925.     if ( q != 0 ) 
  926.     {
  927.       t = fontinfo [ 1 + parambase [ f ] ] .cint / ((double) 65536.0 ) ; 
  928.       i = fontinfo [ charbase [ f ] + mem [ q ] .hh.b1 ] .qqqq ; 
  929.       w = fontinfo [ widthbase [ f ] + i .b0 ] .cint ; 
  930.       h = fontinfo [ heightbase [ f ] + ( i .b1 ) / 16 ] .cint ; 
  931.       if ( h != x ) 
  932.       {
  933.     p = hpack ( p , 0 , 1 ) ; 
  934.     mem [ p + 4 ] .cint = x - h ; 
  935.       } 
  936.       delta = round ( ( w - a ) / ((double) 2.0 ) + h * t - x * s ) ; 
  937.       r = newkern ( delta ) ; 
  938.       mem [ r ] .hh.b1 = 2 ; 
  939.       mem [ curlist .tailfield ] .hh .v.RH = r ; 
  940.       mem [ r ] .hh .v.RH = p ; 
  941.       curlist .tailfield = newkern ( - (integer) a - delta ) ; 
  942.       mem [ curlist .tailfield ] .hh.b1 = 2 ; 
  943.       mem [ p ] .hh .v.RH = curlist .tailfield ; 
  944.       p = q ; 
  945.     } 
  946.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  947.     curlist .tailfield = p ; 
  948.     curlist .auxfield = 1000 ; 
  949.   } 
  950. } 
  951. alignerror () {
  952.     alignerror_regmem 
  953.   if ( abs ( alignstate ) > 2 ) 
  954.   {
  955.     {
  956.       if ( interaction == 3 ) 
  957.       wakeupterminal () ; 
  958.       printnl ( 133 ) ; 
  959.       print ( 962 ) ; 
  960.     } 
  961.     printcmdchr ( curcmd , curchr ) ; 
  962.     if ( curtok == 1062 ) 
  963.     {
  964.       {
  965.     helpptr = 6 ; 
  966.     helpline [ 5 ] = 963 ; 
  967.     helpline [ 4 ] = 964 ; 
  968.     helpline [ 3 ] = 965 ; 
  969.     helpline [ 2 ] = 966 ; 
  970.     helpline [ 1 ] = 967 ; 
  971.     helpline [ 0 ] = 968 ; 
  972.       } 
  973.     } 
  974.     else {
  975.     
  976.       {
  977.     helpptr = 5 ; 
  978.     helpline [ 4 ] = 963 ; 
  979.     helpline [ 3 ] = 969 ; 
  980.     helpline [ 2 ] = 966 ; 
  981.     helpline [ 1 ] = 967 ; 
  982.     helpline [ 0 ] = 968 ; 
  983.       } 
  984.     } 
  985.     error () ; 
  986.   } 
  987.   else {
  988.       
  989.     backinput () ; 
  990.     if ( alignstate < 0 ) 
  991.     {
  992.       {
  993.     if ( interaction == 3 ) 
  994.     wakeupterminal () ; 
  995.     printnl ( 133 ) ; 
  996.     print ( 515 ) ; 
  997.       } 
  998.       incr ( alignstate ) ; 
  999.       curtok = 379 ; 
  1000.     } 
  1001.     else {
  1002.     
  1003.       {
  1004.     if ( interaction == 3 ) 
  1005.     wakeupterminal () ; 
  1006.     printnl ( 133 ) ; 
  1007.     print ( 958 ) ; 
  1008.       } 
  1009.       decr ( alignstate ) ; 
  1010.       curtok = 637 ; 
  1011.     } 
  1012.     {
  1013.       helpptr = 3 ; 
  1014.       helpline [ 2 ] = 959 ; 
  1015.       helpline [ 1 ] = 960 ; 
  1016.       helpline [ 0 ] = 961 ; 
  1017.     } 
  1018.     inserror () ; 
  1019.   } 
  1020. } 
  1021. noalignerror () {
  1022.     noalignerror_regmem 
  1023.   {
  1024.     if ( interaction == 3 ) 
  1025.     wakeupterminal () ; 
  1026.     printnl ( 133 ) ; 
  1027.     print ( 962 ) ; 
  1028.   } 
  1029.   printesc ( 386 ) ; 
  1030.   {
  1031.     helpptr = 2 ; 
  1032.     helpline [ 1 ] = 970 ; 
  1033.     helpline [ 0 ] = 971 ; 
  1034.   } 
  1035.   error () ; 
  1036. } 
  1037. omiterror () {
  1038.     omiterror_regmem 
  1039.   {
  1040.     if ( interaction == 3 ) 
  1041.     wakeupterminal () ; 
  1042.     printnl ( 133 ) ; 
  1043.     print ( 962 ) ; 
  1044.   } 
  1045.   printesc ( 388 ) ; 
  1046.   {
  1047.     helpptr = 2 ; 
  1048.     helpline [ 1 ] = 972 ; 
  1049.     helpline [ 0 ] = 971 ; 
  1050.   } 
  1051.   error () ; 
  1052. } 
  1053. doendv () {
  1054.     doendv_regmem 
  1055.   if ( curgroup == 6 ) 
  1056.   {
  1057.     endgraf () ; 
  1058.     if ( fincol () ) 
  1059.     finrow () ; 
  1060.   } 
  1061.   else offsave () ; 
  1062. } 
  1063. cserror () {
  1064.     cserror_regmem 
  1065.   {
  1066.     if ( interaction == 3 ) 
  1067.     wakeupterminal () ; 
  1068.     printnl ( 133 ) ; 
  1069.     print ( 633 ) ; 
  1070.   } 
  1071.   printesc ( 364 ) ; 
  1072.   {
  1073.     helpptr = 1 ; 
  1074.     helpline [ 0 ] = 974 ; 
  1075.   } 
  1076.   error () ; 
  1077. } 
  1078. zpushmath ( c ) 
  1079. groupcode c ; 
  1080. {pushmath_regmem 
  1081.   pushnest () ; 
  1082.   curlist .modefield = -201 ; 
  1083.   curlist .auxfield = 0 ; 
  1084.   newsavelevel ( c ) ; 
  1085. } 
  1086. initmath () {
  1087.     /* 21 40 45 30 */ initmath_regmem 
  1088.   scaled w  ; 
  1089.   scaled l  ; 
  1090.   scaled s  ; 
  1091.   halfword p  ; 
  1092.   halfword q  ; 
  1093.   internalfontnumber f  ; 
  1094.   integer n  ; 
  1095.   scaled v  ; 
  1096.   scaled d  ; 
  1097.   gettoken () ; 
  1098.   if ( ( curcmd == 3 ) && ( curlist .modefield > 0 ) ) 
  1099.   {
  1100.     if ( curlist .headfield == curlist .tailfield ) 
  1101.     {
  1102.       popnest () ; 
  1103.       w = -1073741823L ; 
  1104.     } 
  1105.     else {
  1106.     
  1107.       linebreak ( eqtb [ 5274 ] .cint ) ; 
  1108.       v = mem [ justbox + 4 ] .cint + 2 * fontinfo [ 6 + parambase [ eqtb [ 
  1109.       4578 ] .hh .v.RH ] ] .cint ; 
  1110.       w = -1073741823L ; 
  1111.       p = mem [ justbox + 5 ] .hh .v.RH ; 
  1112.       while ( p != 0 ) {
  1113.       
  1114.     lab21: if ( ( p >= himemmin ) ) 
  1115.     {
  1116.       f = mem [ p ] .hh.b0 ; 
  1117.       d = fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + mem [ p 
  1118.       ] .hh.b1 ] .qqqq .b0 ] .cint ; 
  1119.       goto lab40 ; 
  1120.     } 
  1121.     switch ( mem [ p ] .hh.b0 ) 
  1122.     {case 0 : 
  1123.     case 1 : 
  1124.     case 2 : 
  1125.       {
  1126.         d = mem [ p + 1 ] .cint ; 
  1127.         goto lab40 ; 
  1128.       } 
  1129.       break ; 
  1130.     case 6 : 
  1131.       {
  1132.         mem [ memtop - 12 ] = mem [ p + 1 ] ; 
  1133.         mem [ memtop - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  1134.         p = memtop - 12 ; 
  1135.         goto lab21 ; 
  1136.       } 
  1137.       break ; 
  1138.     case 11 : 
  1139.     case 9 : 
  1140.       d = mem [ p + 1 ] .cint ; 
  1141.       break ; 
  1142.     case 10 : 
  1143.       {
  1144.         q = mem [ p + 1 ] .hh .v.LH ; 
  1145.         d = mem [ q + 1 ] .cint ; 
  1146.         if ( mem [ justbox + 5 ] .hh.b0 == 1 ) 
  1147.         {
  1148.           if ( ( mem [ justbox + 5 ] .hh.b1 == mem [ q ] .hh.b0 ) && ( mem 
  1149.           [ q + 2 ] .cint != 0 ) ) 
  1150.           v = 1073741823L ; 
  1151.         } 
  1152.         else if ( mem [ justbox + 5 ] .hh.b0 == 2 ) 
  1153.         {
  1154.           if ( ( mem [ justbox + 5 ] .hh.b1 == mem [ q ] .hh.b1 ) && ( mem 
  1155.           [ q + 3 ] .cint != 0 ) ) 
  1156.           v = 1073741823L ; 
  1157.         } 
  1158.         if ( mem [ p ] .hh.b1 >= 100 ) 
  1159.         goto lab40 ; 
  1160.       } 
  1161.       break ; 
  1162.     case 8 : 
  1163.       d = 0 ; 
  1164.       break ; 
  1165.       default: 
  1166.       d = 0 ; 
  1167.       break ; 
  1168.     } 
  1169.     if ( v < 1073741823L ) 
  1170.     v = v + d ; 
  1171.     goto lab45 ; 
  1172.     lab40: if ( v < 1073741823L ) 
  1173.     {
  1174.       v = v + d ; 
  1175.       w = v ; 
  1176.     } 
  1177.     else {
  1178.         
  1179.       w = 1073741823L ; 
  1180.       goto lab30 ; 
  1181.     } 
  1182.     lab45: p = mem [ p ] .hh .v.RH ; 
  1183.       } 
  1184.       lab30: ; 
  1185.     } 
  1186.     if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  1187.     if ( ( eqtb [ 5718 ] .cint != 0 ) && ( ( ( eqtb [ 5308 ] .cint >= 0 ) && ( 
  1188.     curlist .pgfield + 2 > eqtb [ 5308 ] .cint ) ) || ( curlist .pgfield + 1 < 
  1189.     - (integer) eqtb [ 5308 ] .cint ) ) ) 
  1190.     {
  1191.       l = eqtb [ 5704 ] .cint - abs ( eqtb [ 5718 ] .cint ) ; 
  1192.       if ( eqtb [ 5718 ] .cint > 0 ) 
  1193.       s = eqtb [ 5718 ] .cint ; 
  1194.       else s = 0 ; 
  1195.     } 
  1196.     else {
  1197.     
  1198.       l = eqtb [ 5704 ] .cint ; 
  1199.       s = 0 ; 
  1200.     } 
  1201.     else {
  1202.     
  1203.       n = mem [ eqtb [ 4056 ] .hh .v.RH ] .hh .v.LH ; 
  1204.       if ( curlist .pgfield + 2 >= n ) 
  1205.       p = eqtb [ 4056 ] .hh .v.RH + 2 * n ; 
  1206.       else p = eqtb [ 4056 ] .hh .v.RH + 2 * ( curlist .pgfield + 2 ) ; 
  1207.       s = mem [ p - 1 ] .cint ; 
  1208.       l = mem [ p ] .cint ; 
  1209.     } 
  1210.     pushmath ( 15 ) ; 
  1211.     curlist .modefield = 201 ; 
  1212.     eqworddefine ( 5311 , -1 ) ; 
  1213.     eqworddefine ( 5714 , w ) ; 
  1214.     eqworddefine ( 5715 , l ) ; 
  1215.     eqworddefine ( 5716 , s ) ; 
  1216.     if ( eqtb [ 4060 ] .hh .v.RH != 0 ) 
  1217.     begintokenlist ( eqtb [ 4060 ] .hh .v.RH , 9 ) ; 
  1218.     if ( nestptr == 1 ) 
  1219.     buildpage () ; 
  1220.   } 
  1221.   else {
  1222.       
  1223.     backinput () ; 
  1224.     {
  1225.       pushmath ( 15 ) ; 
  1226.       eqworddefine ( 5311 , -1 ) ; 
  1227.       if ( eqtb [ 4059 ] .hh .v.RH != 0 ) 
  1228.       begintokenlist ( eqtb [ 4059 ] .hh .v.RH , 8 ) ; 
  1229.     } 
  1230.   } 
  1231. } 
  1232. starteqno () {
  1233.     starteqno_regmem 
  1234.   savestack [ saveptr + 0 ] .cint = curchr ; 
  1235.   incr ( saveptr ) ; 
  1236.   {
  1237.     pushmath ( 15 ) ; 
  1238.     eqworddefine ( 5311 , -1 ) ; 
  1239.     if ( eqtb [ 4059 ] .hh .v.RH != 0 ) 
  1240.     begintokenlist ( eqtb [ 4059 ] .hh .v.RH , 8 ) ; 
  1241.   } 
  1242. } 
  1243. zscanmath ( p ) 
  1244. halfword p ; 
  1245. {/* 20 21 10 */ scanmath_regmem 
  1246.   integer c  ; 
  1247.   lab20: do {
  1248.       getxtoken () ; 
  1249.   } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1250.   lab21: switch ( curcmd ) 
  1251.   {case 11 : 
  1252.   case 12 : 
  1253.   case 67 : 
  1254.     if ( curchr >= 128 ) 
  1255.     c = curchr ; 
  1256.     else {
  1257.     
  1258.       c = eqtb [ 5139 + curchr ] .hh .v.RH ; 
  1259.       if ( c == 32768L ) 
  1260.       {
  1261.     {
  1262.       curcs = curchr + 1 ; 
  1263.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  1264.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  1265.       xtoken () ; 
  1266.       backinput () ; 
  1267.     } 
  1268.     goto lab20 ; 
  1269.       } 
  1270.     } 
  1271.     break ; 
  1272.   case 16 : 
  1273.     {
  1274.       scancharnum () ; 
  1275.       curchr = curval ; 
  1276.       curcmd = 67 ; 
  1277.       goto lab21 ; 
  1278.     } 
  1279.     break ; 
  1280.   case 17 : 
  1281.     {
  1282.       scanfifteenbitint () ; 
  1283.       c = curval ; 
  1284.     } 
  1285.     break ; 
  1286.   case 68 : 
  1287.     c = curchr ; 
  1288.     break ; 
  1289.   case 15 : 
  1290.     {
  1291.       scantwentysevenbitin () ; 
  1292.       c = curval / 4096 ; 
  1293.     } 
  1294.     break ; 
  1295.     default: 
  1296.     {
  1297.       backinput () ; 
  1298.       scanleftbrace () ; 
  1299.       savestack [ saveptr + 0 ] .cint = p ; 
  1300.       incr ( saveptr ) ; 
  1301.       pushmath ( 9 ) ; 
  1302.       return ; 
  1303.     } 
  1304.     break ; 
  1305.   } 
  1306.   mem [ p ] .hh .v.RH = 1 ; 
  1307.   mem [ p ] .hh.b1 = c % 256 ; 
  1308.   if ( ( c >= 28672 ) && ( ( eqtb [ 5311 ] .cint >= 0 ) && ( eqtb [ 5311 ] 
  1309.   .cint < 16 ) ) ) 
  1310.   mem [ p ] .hh.b0 = eqtb [ 5311 ] .cint ; 
  1311.   else mem [ p ] .hh.b0 = ( c / 256 ) % 16 ; 
  1312. } 
  1313. zsetmathchar ( c ) 
  1314. integer c ; 
  1315. {setmathchar_regmem 
  1316.   halfword p  ; 
  1317.   if ( c >= 32768L ) 
  1318.   {
  1319.     curcs = curchr + 1 ; 
  1320.     curcmd = eqtb [ curcs ] .hh.b0 ; 
  1321.     curchr = eqtb [ curcs ] .hh .v.RH ; 
  1322.     xtoken () ; 
  1323.     backinput () ; 
  1324.   } 
  1325.   else {
  1326.       
  1327.     p = newnoad () ; 
  1328.     mem [ p + 1 ] .hh .v.RH = 1 ; 
  1329.     mem [ p + 1 ] .hh.b1 = c % 256 ; 
  1330.     mem [ p + 1 ] .hh.b0 = ( c / 256 ) % 16 ; 
  1331.     if ( c >= 28672 ) 
  1332.     {
  1333.       if ( ( ( eqtb [ 5311 ] .cint >= 0 ) && ( eqtb [ 5311 ] .cint < 16 ) ) ) 
  1334.       mem [ p + 1 ] .hh.b0 = eqtb [ 5311 ] .cint ; 
  1335.       mem [ p ] .hh.b0 = 16 ; 
  1336.     } 
  1337.     else mem [ p ] .hh.b0 = 16 + ( c / 4096 ) ; 
  1338.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  1339.     curlist .tailfield = p ; 
  1340.   } 
  1341. } 
  1342. mathlimitswitch () {
  1343.     /* 10 */ mathlimitswitch_regmem 
  1344.   if ( curlist .headfield != curlist .tailfield ) 
  1345.   if ( mem [ curlist .tailfield ] .hh.b0 == 17 ) 
  1346.   {
  1347.     mem [ curlist .tailfield ] .hh.b1 = curchr ; 
  1348.     return ; 
  1349.   } 
  1350.   {
  1351.     if ( interaction == 3 ) 
  1352.     wakeupterminal () ; 
  1353.     printnl ( 133 ) ; 
  1354.     print ( 978 ) ; 
  1355.   } 
  1356.   {
  1357.     helpptr = 1 ; 
  1358.     helpline [ 0 ] = 979 ; 
  1359.   } 
  1360.   error () ; 
  1361. } 
  1362. zscandelimiter ( p , r ) 
  1363. halfword p ; 
  1364. boolean r ; 
  1365. {scandelimiter_regmem 
  1366.   if ( r ) 
  1367.   scantwentysevenbitin () ; 
  1368.   else {
  1369.       
  1370.     do {
  1371.     getxtoken () ; 
  1372.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1373.     switch ( curcmd ) 
  1374.     {case 11 : 
  1375.     case 12 : 
  1376.       curval = eqtb [ 5573 + curchr ] .cint ; 
  1377.       break ; 
  1378.     case 15 : 
  1379.       scantwentysevenbitin () ; 
  1380.       break ; 
  1381.       default: 
  1382.       curval = -1 ; 
  1383.       break ; 
  1384.     } 
  1385.   } 
  1386.   if ( curval < 0 ) 
  1387.   {
  1388.     {
  1389.       if ( interaction == 3 ) 
  1390.       wakeupterminal () ; 
  1391.       printnl ( 133 ) ; 
  1392.       print ( 980 ) ; 
  1393.     } 
  1394.     {
  1395.       helpptr = 6 ; 
  1396.       helpline [ 5 ] = 981 ; 
  1397.       helpline [ 4 ] = 982 ; 
  1398.       helpline [ 3 ] = 983 ; 
  1399.       helpline [ 2 ] = 984 ; 
  1400.       helpline [ 1 ] = 985 ; 
  1401.       helpline [ 0 ] = 986 ; 
  1402.     } 
  1403.     backerror () ; 
  1404.     curval = 0 ; 
  1405.   } 
  1406.   mem [ p ] .qqqq .b0 = ( curval / 1048576L ) % 16 ; 
  1407.   mem [ p ] .qqqq .b1 = ( curval / 4096 ) % 256 ; 
  1408.   mem [ p ] .qqqq .b2 = ( curval / 256 ) % 16 ; 
  1409.   mem [ p ] .qqqq .b3 = curval % 256 ; 
  1410. } 
  1411. mathradical () {
  1412.     mathradical_regmem 
  1413.   {
  1414.     mem [ curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  1415.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1416.   } 
  1417.   mem [ curlist .tailfield ] .hh.b0 = 24 ; 
  1418.   mem [ curlist .tailfield ] .hh.b1 = 0 ; 
  1419.   mem [ curlist .tailfield + 1 ] .hh = emptyfield ; 
  1420.   mem [ curlist .tailfield + 3 ] .hh = emptyfield ; 
  1421.   mem [ curlist .tailfield + 2 ] .hh = emptyfield ; 
  1422.   scandelimiter ( curlist .tailfield + 4 , true ) ; 
  1423.   scanmath ( curlist .tailfield + 1 ) ; 
  1424. } 
  1425. mathac () {
  1426.     mathac_regmem 
  1427.   if ( curcmd == 45 ) 
  1428.   {
  1429.     {
  1430.       if ( interaction == 3 ) 
  1431.       wakeupterminal () ; 
  1432.       printnl ( 133 ) ; 
  1433.       print ( 987 ) ; 
  1434.     } 
  1435.     printesc ( 382 ) ; 
  1436.     print ( 988 ) ; 
  1437.     {
  1438.       helpptr = 2 ; 
  1439.       helpline [ 1 ] = 989 ; 
  1440.       helpline [ 0 ] = 990 ; 
  1441.     } 
  1442.     error () ; 
  1443.   } 
  1444.   {
  1445.     mem [ curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  1446.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1447.   } 
  1448.   mem [ curlist .tailfield ] .hh.b0 = 28 ; 
  1449.   mem [ curlist .tailfield ] .hh.b1 = 0 ; 
  1450.   mem [ curlist .tailfield + 1 ] .hh = emptyfield ; 
  1451.   mem [ curlist .tailfield + 3 ] .hh = emptyfield ; 
  1452.   mem [ curlist .tailfield + 2 ] .hh = emptyfield ; 
  1453.   mem [ curlist .tailfield + 4 ] .hh .v.RH = 1 ; 
  1454.   scanfifteenbitint () ; 
  1455.   mem [ curlist .tailfield + 4 ] .hh.b1 = curval % 256 ; 
  1456.   if ( ( curval >= 28672 ) && ( ( eqtb [ 5311 ] .cint >= 0 ) && ( eqtb [ 5311 
  1457.   ] .cint < 16 ) ) ) 
  1458.   mem [ curlist .tailfield + 4 ] .hh.b0 = eqtb [ 5311 ] .cint ; 
  1459.   else mem [ curlist .tailfield + 4 ] .hh.b0 = ( curval / 256 ) % 16 ; 
  1460.   scanmath ( curlist .tailfield + 1 ) ; 
  1461. } 
  1462. appendchoices () {
  1463.     appendchoices_regmem 
  1464.   {
  1465.     mem [ curlist .tailfield ] .hh .v.RH = newchoice () ; 
  1466.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1467.   } 
  1468.   incr ( saveptr ) ; 
  1469.   savestack [ saveptr - 1 ] .cint = 0 ; 
  1470.   scanleftbrace () ; 
  1471.   pushmath ( 13 ) ; 
  1472. } 
  1473. halfword zfinmlist ( p ) 
  1474. halfword p ; 
  1475. {register halfword Result; finmlist_regmem 
  1476.   halfword q  ; 
  1477.   if ( curlist .auxfield != 0 ) 
  1478.   {
  1479.     mem [ curlist .auxfield + 3 ] .hh .v.RH = 3 ; 
  1480.     mem [ curlist .auxfield + 3 ] .hh .v.LH = mem [ curlist .headfield ] .hh 
  1481.     .v.RH ; 
  1482.     if ( p == 0 ) 
  1483.     q = curlist .auxfield ; 
  1484.     else {
  1485.     
  1486.       q = mem [ curlist .auxfield + 2 ] .hh .v.LH ; 
  1487.       if ( mem [ q ] .hh.b0 != 30 ) 
  1488.       confusion ( 730 ) ; 
  1489.       mem [ curlist .auxfield + 2 ] .hh .v.LH = mem [ q ] .hh .v.RH ; 
  1490.       mem [ q ] .hh .v.RH = curlist .auxfield ; 
  1491.       mem [ curlist .auxfield ] .hh .v.RH = p ; 
  1492.     } 
  1493.   } 
  1494.   else {
  1495.       
  1496.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  1497.     q = mem [ curlist .headfield ] .hh .v.RH ; 
  1498.   } 
  1499.   popnest () ; 
  1500.   Result = q ; 
  1501.   return(Result) ; 
  1502. } 
  1503. buildchoices () {
  1504.     /* 10 */ buildchoices_regmem 
  1505.   halfword p  ; 
  1506.   unsave () ; 
  1507.   p = finmlist ( 0 ) ; 
  1508.   switch ( savestack [ saveptr - 1 ] .cint ) 
  1509.   {case 0 : 
  1510.     mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  1511.     break ; 
  1512.   case 1 : 
  1513.     mem [ curlist .tailfield + 1 ] .hh .v.RH = p ; 
  1514.     break ; 
  1515.   case 2 : 
  1516.     mem [ curlist .tailfield + 2 ] .hh .v.LH = p ; 
  1517.     break ; 
  1518.   case 3 : 
  1519.     {
  1520.       mem [ curlist .tailfield + 2 ] .hh .v.RH = p ; 
  1521.       decr ( saveptr ) ; 
  1522.       return ; 
  1523.     } 
  1524.     break ; 
  1525.   } 
  1526.   incr ( savestack [ saveptr - 1 ] .cint ) ; 
  1527.   scanleftbrace () ; 
  1528.   pushmath ( 13 ) ; 
  1529. } 
  1530. subsup () {
  1531.     subsup_regmem 
  1532.   smallnumber t  ; 
  1533.   halfword p  ; 
  1534.   t = 0 ; 
  1535.   p = 0 ; 
  1536.   if ( curlist .tailfield != curlist .headfield ) 
  1537.   if ( ( mem [ curlist .tailfield ] .hh.b0 >= 16 ) && ( mem [ curlist 
  1538.   .tailfield ] .hh.b0 < 30 ) ) 
  1539.   {
  1540.     p = curlist .tailfield + 2 + curcmd - 7 ; 
  1541.     t = mem [ p ] .hh .v.RH ; 
  1542.   } 
  1543.   if ( ( p == 0 ) || ( t != 0 ) ) 
  1544.   {
  1545.     {
  1546.       mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  1547.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1548.     } 
  1549.     p = curlist .tailfield + 2 + curcmd - 7 ; 
  1550.     if ( t != 0 ) 
  1551.     {
  1552.       if ( curcmd == 7 ) 
  1553.       {
  1554.     {
  1555.       if ( interaction == 3 ) 
  1556.       wakeupterminal () ; 
  1557.       printnl ( 133 ) ; 
  1558.       print ( 991 ) ; 
  1559.     } 
  1560.     {
  1561.       helpptr = 1 ; 
  1562.       helpline [ 0 ] = 992 ; 
  1563.     } 
  1564.       } 
  1565.       else {
  1566.       
  1567.     {
  1568.       if ( interaction == 3 ) 
  1569.       wakeupterminal () ; 
  1570.       printnl ( 133 ) ; 
  1571.       print ( 993 ) ; 
  1572.     } 
  1573.     {
  1574.       helpptr = 1 ; 
  1575.       helpline [ 0 ] = 994 ; 
  1576.     } 
  1577.       } 
  1578.       error () ; 
  1579.     } 
  1580.   } 
  1581.   scanmath ( p ) ; 
  1582. } 
  1583. mathfraction () {
  1584.     mathfraction_regmem 
  1585.   smallnumber c  ; 
  1586.   c = curchr ; 
  1587.   if ( curlist .auxfield != 0 ) 
  1588.   {
  1589.     if ( c >= 3 ) 
  1590.     {
  1591.       scandelimiter ( memtop - 12 , false ) ; 
  1592.       scandelimiter ( memtop - 12 , false ) ; 
  1593.     } 
  1594.     if ( c % 3 == 0 ) 
  1595.     scandimen ( false , false , false ) ; 
  1596.     {
  1597.       if ( interaction == 3 ) 
  1598.       wakeupterminal () ; 
  1599.       printnl ( 133 ) ; 
  1600.       print ( 1001 ) ; 
  1601.     } 
  1602.     {
  1603.       helpptr = 3 ; 
  1604.       helpline [ 2 ] = 1002 ; 
  1605.       helpline [ 1 ] = 1003 ; 
  1606.       helpline [ 0 ] = 1004 ; 
  1607.     } 
  1608.     error () ; 
  1609.   } 
  1610.   else {
  1611.       
  1612.     curlist .auxfield = getnode ( 6 ) ; 
  1613.     mem [ curlist .auxfield ] .hh.b0 = 25 ; 
  1614.     mem [ curlist .auxfield ] .hh.b1 = 0 ; 
  1615.     mem [ curlist .auxfield + 2 ] .hh .v.RH = 3 ; 
  1616.     mem [ curlist .auxfield + 2 ] .hh .v.LH = mem [ curlist .headfield ] .hh 
  1617.     .v.RH ; 
  1618.     mem [ curlist .auxfield + 3 ] .hh = emptyfield ; 
  1619.     mem [ curlist .auxfield + 4 ] .qqqq = nulldelimiter ; 
  1620.     mem [ curlist .auxfield + 5 ] .qqqq = nulldelimiter ; 
  1621.     mem [ curlist .headfield ] .hh .v.RH = 0 ; 
  1622.     curlist .tailfield = curlist .headfield ; 
  1623.     if ( c >= 3 ) 
  1624.     {
  1625.       scandelimiter ( curlist .auxfield + 4 , false ) ; 
  1626.       scandelimiter ( curlist .auxfield + 5 , false ) ; 
  1627.     } 
  1628.     switch ( c % 3 ) 
  1629.     {case 0 : 
  1630.       {
  1631.     scandimen ( false , false , false ) ; 
  1632.     mem [ curlist .auxfield + 1 ] .cint = curval ; 
  1633.       } 
  1634.       break ; 
  1635.     case 1 : 
  1636.       mem [ curlist .auxfield + 1 ] .cint = 1073741824L ; 
  1637.       break ; 
  1638.     case 2 : 
  1639.       mem [ curlist .auxfield + 1 ] .cint = 0 ; 
  1640.       break ; 
  1641.     } 
  1642.   } 
  1643. } 
  1644. mathleftright () {
  1645.     mathleftright_regmem 
  1646.   smallnumber t  ; 
  1647.   halfword p  ; 
  1648.   t = curchr ; 
  1649.   if ( ( t == 31 ) && ( curgroup != 16 ) ) 
  1650.   {
  1651.     if ( curgroup == 15 ) 
  1652.     {
  1653.       scandelimiter ( memtop - 12 , false ) ; 
  1654.       {
  1655.     if ( interaction == 3 ) 
  1656.     wakeupterminal () ; 
  1657.     printnl ( 133 ) ; 
  1658.     print ( 633 ) ; 
  1659.       } 
  1660.       printesc ( 730 ) ; 
  1661.       {
  1662.     helpptr = 1 ; 
  1663.     helpline [ 0 ] = 1005 ; 
  1664.       } 
  1665.       error () ; 
  1666.     } 
  1667.     else offsave () ; 
  1668.   } 
  1669.   else {
  1670.       
  1671.     p = newnoad () ; 
  1672.     mem [ p ] .hh.b0 = t ; 
  1673.     scandelimiter ( p + 1 , false ) ; 
  1674.     if ( t == 30 ) 
  1675.     {
  1676.       pushmath ( 16 ) ; 
  1677.       mem [ curlist .headfield ] .hh .v.RH = p ; 
  1678.       curlist .tailfield = p ; 
  1679.     } 
  1680.     else {
  1681.     
  1682.       p = finmlist ( p ) ; 
  1683.       unsave () ; 
  1684.       {
  1685.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  1686.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1687.       } 
  1688.       mem [ curlist .tailfield ] .hh.b0 = 23 ; 
  1689.       mem [ curlist .tailfield + 1 ] .hh .v.RH = 3 ; 
  1690.       mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  1691.     } 
  1692.   } 
  1693. } 
  1694. aftermath () {
  1695.     aftermath_regmem 
  1696.   boolean l  ; 
  1697.   boolean danger  ; 
  1698.   integer m  ; 
  1699.   halfword p  ; 
  1700.   halfword a  ; 
  1701.   halfword b  ; 
  1702.   scaled w  ; 
  1703.   scaled z  ; 
  1704.   scaled e  ; 
  1705.   scaled q  ; 
  1706.   scaled d  ; 
  1707.   scaled s  ; 
  1708.   smallnumber g1, g2  ; 
  1709.   halfword r  ; 
  1710.   halfword t  ; 
  1711.   danger = false ; 
  1712.   if ( ( fontparams [ eqtb [ 4581 ] .hh .v.RH ] < 22 ) || ( fontparams [ eqtb 
  1713.   [ 4597 ] .hh .v.RH ] < 22 ) || ( fontparams [ eqtb [ 4613 ] .hh .v.RH ] < 22 
  1714.   ) ) 
  1715.   {
  1716.     {
  1717.       if ( interaction == 3 ) 
  1718.       wakeupterminal () ; 
  1719.       printnl ( 133 ) ; 
  1720.       print ( 1006 ) ; 
  1721.     } 
  1722.     {
  1723.       helpptr = 3 ; 
  1724.       helpline [ 2 ] = 1007 ; 
  1725.       helpline [ 1 ] = 1008 ; 
  1726.       helpline [ 0 ] = 1009 ; 
  1727.     } 
  1728.     error () ; 
  1729.     flushmath () ; 
  1730.     danger = true ; 
  1731.   } 
  1732.   else if ( ( fontparams [ eqtb [ 4582 ] .hh .v.RH ] < 13 ) || ( fontparams [ 
  1733.   eqtb [ 4598 ] .hh .v.RH ] < 13 ) || ( fontparams [ eqtb [ 4614 ] .hh .v.RH ] 
  1734.   < 13 ) ) 
  1735.   {
  1736.     {
  1737.       if ( interaction == 3 ) 
  1738.       wakeupterminal () ; 
  1739.       printnl ( 133 ) ; 
  1740.       print ( 1010 ) ; 
  1741.     } 
  1742.     {
  1743.       helpptr = 3 ; 
  1744.       helpline [ 2 ] = 1011 ; 
  1745.       helpline [ 1 ] = 1012 ; 
  1746.       helpline [ 0 ] = 1013 ; 
  1747.     } 
  1748.     error () ; 
  1749.     flushmath () ; 
  1750.     danger = true ; 
  1751.   } 
  1752.   m = curlist .modefield ; 
  1753.   l = false ; 
  1754.   p = finmlist ( 0 ) ; 
  1755.   if ( curlist .modefield == - (integer) m ) 
  1756.   {
  1757.     curmlist = p ; 
  1758.     curstyle = 2 ; 
  1759.     mlistpenalties = false ; 
  1760.     mlisttohlist () ; 
  1761.     a = hpack ( mem [ memtop - 3 ] .hh .v.RH , 0 , 1 ) ; 
  1762.     unsave () ; 
  1763.     decr ( saveptr ) ; 
  1764.     if ( savestack [ saveptr + 0 ] .cint == 1 ) 
  1765.     l = true ; 
  1766.     if ( danger ) 
  1767.     flushmath () ; 
  1768.     m = curlist .modefield ; 
  1769.     p = finmlist ( 0 ) ; 
  1770.   } 
  1771.   else a = 0 ; 
  1772.   if ( m < 0 ) 
  1773.   {
  1774.     {
  1775.       mem [ curlist .tailfield ] .hh .v.RH = newmath ( eqtb [ 5702 ] .cint , 0 
  1776.       ) ; 
  1777.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1778.     } 
  1779.     curmlist = p ; 
  1780.     curstyle = 2 ; 
  1781.     mlistpenalties = ( curlist .modefield > 0 ) ; 
  1782.     mlisttohlist () ; 
  1783.     mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 3 ] .hh .v.RH ; 
  1784.     while ( mem [ curlist .tailfield ] .hh .v.RH != 0 ) curlist .tailfield = 
  1785.     mem [ curlist .tailfield ] .hh .v.RH ; 
  1786.     {
  1787.       mem [ curlist .tailfield ] .hh .v.RH = newmath ( eqtb [ 5702 ] .cint , 1 
  1788.       ) ; 
  1789.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1790.     } 
  1791.     curlist .auxfield = 1000 ; 
  1792.     unsave () ; 
  1793.   } 
  1794.   else {
  1795.       
  1796.     {
  1797.       getxtoken () ; 
  1798.       if ( curcmd != 3 ) 
  1799.       {
  1800.     {
  1801.       if ( interaction == 3 ) 
  1802.       wakeupterminal () ; 
  1803.       printnl ( 133 ) ; 
  1804.       print ( 1014 ) ; 
  1805.     } 
  1806.     {
  1807.       helpptr = 2 ; 
  1808.       helpline [ 1 ] = 1015 ; 
  1809.       helpline [ 0 ] = 1016 ; 
  1810.     } 
  1811.     backerror () ; 
  1812.       } 
  1813.     } 
  1814.     curmlist = p ; 
  1815.     curstyle = 0 ; 
  1816.     mlistpenalties = false ; 
  1817.     mlisttohlist () ; 
  1818.     p = mem [ memtop - 3 ] .hh .v.RH ; 
  1819.     adjusttail = memtop - 5 ; 
  1820.     b = hpack ( p , 0 , 1 ) ; 
  1821.     t = adjusttail ; 
  1822.     adjusttail = 0 ; 
  1823.     w = mem [ b + 1 ] .cint ; 
  1824.     z = eqtb [ 5715 ] .cint ; 
  1825.     s = eqtb [ 5716 ] .cint ; 
  1826.     if ( ( a == 0 ) || danger ) 
  1827.     {
  1828.       e = 0 ; 
  1829.       q = 0 ; 
  1830.     } 
  1831.     else {
  1832.     
  1833.       e = mem [ a + 1 ] .cint ; 
  1834.       q = e + fontinfo [ 6 + parambase [ eqtb [ 4581 ] .hh .v.RH ] ] .cint ; 
  1835.     } 
  1836.     if ( w + q > z ) 
  1837.     {
  1838.       if ( ( e != 0 ) && ( ( w - totalshrink [ 0 ] + q <= z ) || ( totalshrink 
  1839.       [ 1 ] != 0 ) || ( totalshrink [ 2 ] != 0 ) || ( totalshrink [ 3 ] != 0 ) 
  1840.       ) ) 
  1841.       {
  1842.     freenode ( b , 7 ) ; 
  1843.     b = hpack ( p , z - q , 0 ) ; 
  1844.       } 
  1845.       else {
  1846.       
  1847.     e = 0 ; 
  1848.     if ( w > z ) 
  1849.     {
  1850.       freenode ( b , 7 ) ; 
  1851.       b = hpack ( p , z , 0 ) ; 
  1852.     } 
  1853.       } 
  1854.       w = mem [ b + 1 ] .cint ; 
  1855.     } 
  1856.     d = half ( z - w ) ; 
  1857.     if ( ( e > 0 ) && ( d < 2 * e ) ) 
  1858.     {
  1859.       d = half ( z - w - e ) ; 
  1860.       if ( p != 0 ) 
  1861.       if ( mem [ p ] .hh.b0 == 10 ) 
  1862.       d = 0 ; 
  1863.     } 
  1864.     {
  1865.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5278 ] .cint 
  1866.       ) ; 
  1867.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1868.     } 
  1869.     if ( ( d + s <= eqtb [ 5714 ] .cint ) || l ) 
  1870.     {
  1871.       g1 = 3 ; 
  1872.       g2 = 4 ; 
  1873.     } 
  1874.     else {
  1875.     
  1876.       g1 = 5 ; 
  1877.       g2 = 6 ; 
  1878.     } 
  1879.     if ( l && ( e == 0 ) ) 
  1880.     {
  1881.       mem [ a + 4 ] .cint = s ; 
  1882.       appendtovlist ( a ) ; 
  1883.       {
  1884.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( 10000 ) ; 
  1885.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1886.       } 
  1887.     } 
  1888.     else {
  1889.     
  1890.       mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( g1 ) ; 
  1891.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1892.     } 
  1893.     if ( e != 0 ) 
  1894.     {
  1895.       r = newkern ( z - w - e - d ) ; 
  1896.       if ( l ) 
  1897.       {
  1898.     mem [ a ] .hh .v.RH = r ; 
  1899.     mem [ r ] .hh .v.RH = b ; 
  1900.     b = a ; 
  1901.     d = 0 ; 
  1902.       } 
  1903.       else {
  1904.       
  1905.     mem [ b ] .hh .v.RH = r ; 
  1906.     mem [ r ] .hh .v.RH = a ; 
  1907.       } 
  1908.       b = hpack ( b , 0 , 1 ) ; 
  1909.     } 
  1910.     mem [ b + 4 ] .cint = s + d ; 
  1911.     appendtovlist ( b ) ; 
  1912.     if ( t != memtop - 5 ) 
  1913.     {
  1914.       mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 5 ] .hh .v.RH ; 
  1915.       curlist .tailfield = t ; 
  1916.     } 
  1917.     if ( ( a != 0 ) && ( e == 0 ) && ! l ) 
  1918.     {
  1919.       {
  1920.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( 10000 ) ; 
  1921.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1922.       } 
  1923.       mem [ a + 4 ] .cint = s + z - mem [ a + 1 ] .cint ; 
  1924.       appendtovlist ( a ) ; 
  1925.       {
  1926.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5279 ] 
  1927.     .cint ) ; 
  1928.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1929.       } 
  1930.     } 
  1931.     else {
  1932.     
  1933.       {
  1934.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5279 ] 
  1935.     .cint ) ; 
  1936.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1937.       } 
  1938.       {
  1939.     mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( g2 ) ; 
  1940.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1941.       } 
  1942.     } 
  1943.     resumeafterdisplay () ; 
  1944.   } 
  1945. } 
  1946. resumeafterdisplay () {
  1947.     resumeafterdisplay_regmem 
  1948.   if ( curgroup != 15 ) 
  1949.   confusion ( 1017 ) ; 
  1950.   unsave () ; 
  1951.   curlist .pgfield = curlist .pgfield + 3 ; 
  1952.   pushnest () ; 
  1953.   curlist .modefield = 101 ; 
  1954.   curlist .auxfield = 1000 ; 
  1955.   {
  1956.     getxtoken () ; 
  1957.     if ( curcmd != 10 ) 
  1958.     backinput () ; 
  1959.   } 
  1960.   if ( nestptr == 1 ) 
  1961.   buildpage () ; 
  1962. } 
  1963. getrtoken () {
  1964.     /* 20 */ getrtoken_regmem 
  1965.   lab20: do {
  1966.       gettoken () ; 
  1967.   } while ( ! ( curtok != 2592 ) ) ; 
  1968.   if ( ( curcs == 0 ) || ( curcs > 3258 ) ) 
  1969.   {
  1970.     {
  1971.       if ( interaction == 3 ) 
  1972.       wakeupterminal () ; 
  1973.       printnl ( 133 ) ; 
  1974.       print ( 1032 ) ; 
  1975.     } 
  1976.     {
  1977.       helpptr = 5 ; 
  1978.       helpline [ 4 ] = 1033 ; 
  1979.       helpline [ 3 ] = 1034 ; 
  1980.       helpline [ 2 ] = 1035 ; 
  1981.       helpline [ 1 ] = 1036 ; 
  1982.       helpline [ 0 ] = 1037 ; 
  1983.     } 
  1984.     if ( curcs == 0 ) 
  1985.     backinput () ; 
  1986.     curtok = 7354 ; 
  1987.     inserror () ; 
  1988.     goto lab20 ; 
  1989.   } 
  1990. } 
  1991. trapzeroglue () {
  1992.     trapzeroglue_regmem 
  1993.   if ( ( mem [ curval + 1 ] .cint == 0 ) && ( mem [ curval + 2 ] .cint == 0 ) 
  1994.   && ( mem [ curval + 3 ] .cint == 0 ) ) 
  1995.   {
  1996.     incr ( mem [ 0 ] .hh .v.RH ) ; 
  1997.     deleteglueref ( curval ) ; 
  1998.     curval = 0 ; 
  1999.   } 
  2000. } 
  2001. zdoregistercommand ( a ) 
  2002. smallnumber a ; 
  2003. {/* 40 10 */ doregistercommand_regmem 
  2004.   halfword l, q, r, s  ; 
  2005.   schar p  ; 
  2006.   q = curcmd ; 
  2007.   {
  2008.     if ( q != 88 ) 
  2009.     {
  2010.       getxtoken () ; 
  2011.       if ( ( curcmd >= 72 ) && ( curcmd <= 75 ) ) 
  2012.       {
  2013.     l = curchr ; 
  2014.     p = curcmd - 72 ; 
  2015.     goto lab40 ; 
  2016.       } 
  2017.       if ( curcmd != 88 ) 
  2018.       {
  2019.     {
  2020.       if ( interaction == 3 ) 
  2021.       wakeupterminal () ; 
  2022.       printnl ( 133 ) ; 
  2023.       print ( 541 ) ; 
  2024.     } 
  2025.     printcmdchr ( curcmd , curchr ) ; 
  2026.     print ( 542 ) ; 
  2027.     printcmdchr ( q , 0 ) ; 
  2028.     {
  2029.       helpptr = 1 ; 
  2030.       helpline [ 0 ] = 1058 ; 
  2031.     } 
  2032.     error () ; 
  2033.     return ; 
  2034.       } 
  2035.     } 
  2036.     p = curchr ; 
  2037.     scaneightbitint () ; 
  2038.     switch ( p ) 
  2039.     {case 0 : 
  2040.       l = curval + 5317 ; 
  2041.       break ; 
  2042.     case 1 : 
  2043.       l = curval + 5721 ; 
  2044.       break ; 
  2045.     case 2 : 
  2046.       l = curval + 3544 ; 
  2047.       break ; 
  2048.     case 3 : 
  2049.       l = curval + 3800 ; 
  2050.       break ; 
  2051.     } 
  2052.   } 
  2053.   lab40: ; 
  2054.   if ( q == 88 ) 
  2055.   scanoptionalequals () ; 
  2056.   else if ( scankeyword ( 1054 ) ) 
  2057.   ; 
  2058.   aritherror = false ; 
  2059.   if ( q < 90 ) 
  2060.   if ( p < 2 ) 
  2061.   {
  2062.     if ( p == 0 ) 
  2063.     scanint () ; 
  2064.     else scandimen ( false , false , false ) ; 
  2065.     if ( q == 89 ) 
  2066.     curval = curval + eqtb [ l ] .cint ; 
  2067.   } 
  2068.   else {
  2069.       
  2070.     scanglue ( p ) ; 
  2071.     if ( q == 89 ) 
  2072.     {
  2073.       q = newspec ( curval ) ; 
  2074.       r = eqtb [ l ] .hh .v.RH ; 
  2075.       deleteglueref ( curval ) ; 
  2076.       mem [ q + 1 ] .cint = mem [ q + 1 ] .cint + mem [ r + 1 ] .cint ; 
  2077.       if ( mem [ q + 2 ] .cint == 0 ) 
  2078.       mem [ q ] .hh.b0 = 0 ; 
  2079.       if ( mem [ q ] .hh.b0 == mem [ r ] .hh.b0 ) 
  2080.       mem [ q + 2 ] .cint = mem [ q + 2 ] .cint + mem [ r + 2 ] .cint ; 
  2081.       else if ( ( mem [ q ] .hh.b0 < mem [ r ] .hh.b0 ) && ( mem [ r + 2 ] 
  2082.       .cint != 0 ) ) 
  2083.       {
  2084.     mem [ q + 2 ] .cint = mem [ r + 2 ] .cint ; 
  2085.     mem [ q ] .hh.b0 = mem [ r ] .hh.b0 ; 
  2086.       } 
  2087.       if ( mem [ q + 3 ] .cint == 0 ) 
  2088.       mem [ q ] .hh.b1 = 0 ; 
  2089.       if ( mem [ q ] .hh.b1 == mem [ r ] .hh.b1 ) 
  2090.       mem [ q + 3 ] .cint = mem [ q + 3 ] .cint + mem [ r + 3 ] .cint ; 
  2091.       else if ( ( mem [ q ] .hh.b1 < mem [ r ] .hh.b1 ) && ( mem [ r + 3 ] 
  2092.       .cint != 0 ) ) 
  2093.       {
  2094.     mem [ q + 3 ] .cint = mem [ r + 3 ] .cint ; 
  2095.     mem [ q ] .hh.b1 = mem [ r ] .hh.b1 ; 
  2096.       } 
  2097.       curval = q ; 
  2098.     } 
  2099.   } 
  2100.   else {
  2101.       
  2102.     scanint () ; 
  2103.     if ( p < 2 ) 
  2104.     if ( q == 90 ) 
  2105.     curval = nxplusy ( eqtb [ l ] .cint , curval , 0 ) ; 
  2106.     else curval = xovern ( eqtb [ l ] .cint , curval ) ; 
  2107.     else {
  2108.     
  2109.       s = eqtb [ l ] .hh .v.RH ; 
  2110.       r = newspec ( s ) ; 
  2111.       if ( q == 90 ) 
  2112.       {
  2113.     mem [ r + 1 ] .cint = nxplusy ( mem [ s + 1 ] .cint , curval , 0 ) ; 
  2114.     mem [ r + 2 ] .cint = nxplusy ( mem [ s + 2 ] .cint , curval , 0 ) ; 
  2115.     mem [ r + 3 ] .cint = nxplusy ( mem [ s + 3 ] .cint , curval , 0 ) ; 
  2116.       } 
  2117.       else {
  2118.       
  2119.     mem [ r + 1 ] .cint = xovern ( mem [ s + 1 ] .cint , curval ) ; 
  2120.     mem [ r + 2 ] .cint = xovern ( mem [ s + 2 ] .cint , curval ) ; 
  2121.     mem [ r + 3 ] .cint = xovern ( mem [ s + 3 ] .cint , curval ) ; 
  2122.       } 
  2123.       curval = r ; 
  2124.     } 
  2125.   } 
  2126.   if ( aritherror ) 
  2127.   {
  2128.     {
  2129.       if ( interaction == 3 ) 
  2130.       wakeupterminal () ; 
  2131.       printnl ( 133 ) ; 
  2132.       print ( 1055 ) ; 
  2133.     } 
  2134.     {
  2135.       helpptr = 2 ; 
  2136.       helpline [ 1 ] = 1056 ; 
  2137.       helpline [ 0 ] = 1057 ; 
  2138.     } 
  2139.     error () ; 
  2140.     return ; 
  2141.   } 
  2142.   if ( p < 2 ) 
  2143.   if ( ( a >= 4 ) ) 
  2144.   geqworddefine ( l , curval ) ; 
  2145.   else eqworddefine ( l , curval ) ; 
  2146.   else {
  2147.       
  2148.     trapzeroglue () ; 
  2149.     if ( ( a >= 4 ) ) 
  2150.     geqdefine ( l , 116 , curval ) ; 
  2151.     else eqdefine ( l , 116 , curval ) ; 
  2152.   } 
  2153. } 
  2154.